home *** CD-ROM | disk | FTP | other *** search
/ TPUG - Toronto PET Users Group / TPUG Users Group CD / TPUG Users Group CD.iso / AMIGA / (A)Z / (A)Z11.ADF / LOGO / LOGOSOURCE / amiga.c next >
C/C++ Source or Header  |  1987-07-21  |  8KB  |  434 lines
  1. /* Include file for turtle.c for AMIGA */
  2. /* July '87 - Scott Evernden */
  3.  
  4. #if 1
  5. #define LOGGER(b)
  6. #else
  7. #define LOGGER(b)    { printf b; fflush(stdout); }
  8. #endif
  9.  
  10.  
  11. #include <math.h>
  12. #include "logo.h"
  13. #include "amiga.h"
  14.  
  15. struct Task *FindTask();
  16. APTR origExceptCode, origExceptData;
  17. int origExceptSigs;
  18.  
  19. extern void *IconBase;
  20. extern struct WBStartup *WBenchMsg;
  21. static int from_wb;
  22.  
  23. struct IntuitionBase *IntuitionBase;
  24. struct GfxBase *GfxBase;
  25. struct Region *region, *NewRegion();
  26. struct Library *LayersBase, *OpenLibrary();
  27. struct Window *twin, *OpenWindow();
  28.  
  29. struct NewWindow new_twin = {
  30.     640 - (4 + 400 + 4), 0,
  31.     4 + 400 + 4, 11 + 172 + 2,
  32.     -1, -1,
  33.     0,
  34.     WINDOWDRAG | WINDOWDEPTH | SMART_REFRESH | NOCAREREFRESH,
  35.     NULL, NULL, 
  36.     (UBYTE *) "LOGO Turtle Window",
  37.     NULL, NULL, 
  38.     100, 100,
  39.     999, 999,
  40.     WBENCHSCREEN
  41. };
  42.  
  43.  
  44. char editor_name[64];
  45.  
  46. static struct Task *myTask;
  47. static int centx, centy;    /* turtle window center */
  48.  
  49. struct RastPort *rp;
  50. struct Window *w;
  51.  
  52. extern int penerase;
  53. extern NUMBER yscrunch;
  54. extern struct display *mydpy, amiga;
  55.  
  56. extern struct Task *FindTask();
  57.  
  58. /*******************************************************/
  59.  
  60. amgturt(hide)
  61. int hide;    /* nonzero to erase turtle */
  62. {
  63.     long sx,sy,x,y;
  64.     double angle;
  65.  
  66. LOGGER(("amgturt(%d): ", hide));
  67.  
  68.     SetDrMd(rp,COMPLEMENT);
  69.  
  70.     angle = mydpy->turth*(3.141592654/180.0);
  71.     sx = x = mydpy->turtx + 15.0*sin(angle);
  72.     sy = y = yscrunch * (mydpy->turty + 15.0*cos(angle));
  73. LOGGER(("(%d,%d)",x,y));
  74.     Move(rp,centx+x,centy-y);
  75.  
  76.     angle = (mydpy->turth-90.0)*(3.141592654/180.0);
  77.     x = mydpy->turtx + 15.0*sin(angle);
  78.     y = yscrunch * (mydpy->turty + 15.0*cos(angle));
  79. LOGGER(("(%d,%d)",x,y));
  80.     Draw(rp,centx+x,centy-y);
  81.  
  82.     angle = (mydpy->turth+90.0)*(3.141592654/180.0);
  83.     x = mydpy->turtx + 15.0*sin(angle);
  84.     y = yscrunch * (mydpy->turty + 15.0*cos(angle));
  85. LOGGER(("(%d,%d)",x,y));
  86.     Draw(rp,centx+x,centy-y);
  87.  
  88. LOGGER(("(%d,%d)\n",sx,sy));
  89.     Draw(rp,centx+sx,centy-sy);
  90.     WritePixel(rp,centx+sx,centy-sy);
  91. }
  92.  
  93. amgfrom(x,y)
  94. NUMBER x,y;
  95. {
  96. LOGGER(("amgfrom(%d,%d)\n", (long)x,(long)y));
  97.     Move(rp,centx+(long)x,centy-(long)y);
  98. }
  99.  
  100. amgto(x,y)
  101. NUMBER x,y;
  102. {
  103.     static long amgpens[] = {JAM1,JAM1|INVERSVID,COMPLEMENT};
  104.  
  105. LOGGER(("amgto(%d,%d)\n", (long)x,(long)y));
  106.     SetDrMd(rp,amgpens[penerase]);
  107.     Draw(rp,centx+(long)x,centy-(long)y);
  108. }
  109.  
  110. amgin()
  111. {
  112.     struct Rectangle rect;
  113.     int t, wid, hyt;
  114.  
  115. LOGGER(("amgin()\n"));
  116.  
  117.     if (twin)
  118.         return;
  119.  
  120.     twin = OpenWindow(&new_twin);
  121.     if (!twin)
  122.         fault("opening turtle window");
  123.  
  124.     rp = twin->RPort;
  125.     SetAPen(rp, 1L);
  126.  
  127.     rect.MinX = twin->BorderLeft;
  128.     rect.MinY = twin->BorderTop;
  129.     rect.MaxX = twin->Width - twin->BorderRight,
  130.     rect.MaxY = twin->Height - twin->BorderBottom;
  131.  
  132. LOGGER(("min (%d,%d) - max (%d,%d)\n",
  133.         rect.MinX, rect.MinY, rect.MaxX, rect.MaxY));
  134.  
  135.     ClearRegion(region);
  136.     OrRectRegion(region, &rect);
  137.     InstallClipRegion(rp->Layer, region);
  138.  
  139.     wid = rect.MaxX - rect.MinX;
  140.     hyt = rect.MaxY - rect.MinY;
  141.  
  142.     t = wid / 2;
  143.     centx = twin->BorderLeft + t;
  144.     mydpy->xlow = -t;
  145.     mydpy->xhigh = wid - t;
  146.  
  147.     t = hyt / 2;
  148.     centy = twin->BorderTop + t;
  149.     mydpy->ylow = (-t) / mydpy->stdscrunch;
  150.     mydpy->yhigh = (hyt - t) / mydpy->stdscrunch;
  151.  
  152. LOGGER(("center (%d,%d)\n", centx, centy));
  153. LOGGER(("xlow,ylow (%d,%d)\n", (int)mydpy->xlow, (int)mydpy->ylow));
  154. LOGGER(("xhigh,yhigh (%d,%d)\n", (int)mydpy->xhigh, (int)mydpy->yhigh));
  155.  
  156. }
  157.  
  158. amgout()
  159. {
  160. LOGGER(("amgout()\n"));
  161.  
  162.     if (!twin)
  163.         return;
  164.  
  165.     InstallClipRegion(rp->Layer, (struct Region *) NULL);
  166.     CloseWindow(twin);
  167.     twin = rp = NULL;
  168. }
  169.  
  170. amgpenc(ipen)
  171. int ipen;
  172. {
  173. LOGGER(("amgpenc(%d)\n",ipen));
  174.  
  175.     if (ipen<0 || ipen>3) {
  176.         puts("The pen color must be 0 to 3.");
  177.         errhand();
  178.     }
  179.     SetAPen(rp,(long)ipen);
  180. }
  181.  
  182. amgstate(which)
  183. {
  184. LOGGER(("amgstate(%c)\n", which));
  185.     if (!rp)
  186.         return;
  187.  
  188.     switch (which) {
  189.     case 'c':
  190.     case 'w':
  191.         SetRast(rp, 0L);
  192.         break;
  193.  
  194.     case 'f':
  195.     case 's':
  196.         printf("Hey, I am NOT an Atari computer!\n");
  197.         errhand();
  198.         break;
  199.     }
  200. }
  201.  
  202. /*******************************************************************/
  203.  
  204. wb_start()
  205. {
  206.     char *cp;
  207.     struct DiskObject *dop;
  208.  
  209.     from_wb++;
  210.  
  211.     IconBase = OpenLibrary("icon.library", 0L);
  212.     if (!IconBase)
  213.         fault("opening icon library");
  214.  
  215.     dop = GetDiskObject(WBenchMsg->sm_ArgList->wa_Name);
  216.     if (dop) {
  217.         cp = FindToolType(dop->do_ToolTypes, "EDITOR");
  218.         if (cp)
  219.             strcpy(editor_name, cp);
  220.         FreeDiskObject(dop);
  221.     }
  222.     CloseLibrary(IconBase);
  223. }
  224.  
  225.  
  226. amiga_start(argc, argv)
  227. int argc;
  228. char *argv[];
  229. {
  230.     extern int Enable_Abort, exceptSig, exceptCode();
  231.  
  232.     Enable_Abort = 0;
  233.  
  234.     if (argc == 0)
  235.         wb_start();
  236.  
  237.     myTask = FindTask((char *) NULL);
  238.  
  239.     origExceptCode = myTask->tc_ExceptCode;
  240.     origExceptData = myTask->tc_ExceptData;
  241.     origExceptSigs = SetExcept(-1, 0);
  242.  
  243.     myTask->tc_ExceptCode = (APTR) exceptCode;
  244.     myTask->tc_ExceptData = (APTR) &exceptSig;
  245.  
  246.     IntuitionBase = (struct IntuitionBase *)
  247.                         OpenLibrary("intuition.library", 0L);
  248.     if (!IntuitionBase)
  249.         fault("opening intuition");
  250.  
  251.     GfxBase = (struct GfxBase *)
  252.                         OpenLibrary("graphics.library", 0L);
  253.     if (!GfxBase)
  254.         fault("opening graphics");
  255.  
  256.     if (GfxBase->Modes & INTERLACE) {
  257.         new_twin.Height = 11 + 344 + 2;
  258.         amiga.ylow = -172.0;
  259.         amiga.yhigh = 172.0;
  260.         amiga.stdscrunch = .86;
  261.     }
  262.  
  263.     LayersBase = OpenLibrary("layers.library", 33L);
  264.     if (!LayersBase)
  265.         fault("opening layers");
  266.  
  267.     region = NewRegion();
  268.     if (!region)
  269.         fault("opening region");
  270. }
  271.  
  272. amiga_end()
  273. {
  274.     amgout();
  275.  
  276.     if (region)
  277.         DisposeRegion(region);
  278.  
  279.     if (LayersBase)
  280.         CloseLibrary(LayersBase);
  281.  
  282.     if (GfxBase)
  283.         CloseLibrary(GfxBase);
  284.  
  285.     if (IntuitionBase)
  286.         CloseLibrary(IntuitionBase);
  287.  
  288.     SetExcept(0, -1);
  289.  
  290.     myTask->tc_ExceptCode = origExceptCode;
  291.     myTask->tc_ExceptData = origExceptData;
  292.  
  293.     SetExcept(origExceptSigs, -1);
  294. }
  295.  
  296. /*******************************************************************/
  297.  
  298. /* replacement _abort */
  299. _abort()
  300. {
  301.     amiga_end();
  302.     exit(0);
  303. }
  304.  
  305. abort()
  306. {
  307.     _abort();
  308. }
  309.  
  310. fault(msg)
  311. char *msg;
  312. {
  313.     printf("Error %s.\n", msg);
  314.     fflush(stdout);
  315.     amiga_end();
  316.     exit(0);
  317. }
  318.  
  319. /*******************************************************************/
  320.  
  321. int quitsig = 0;
  322. int exceptSig = 0;
  323. int exceptSigs = 0;
  324. int exceptFlag = 0;
  325. int (*intrCode)();
  326. int (*quitCode)();
  327.  
  328. #asm
  329.  
  330.     public    _exceptCode
  331.     public    _geta4
  332.     public    _exceptHandler
  333.  
  334. _exceptCode:
  335.     move.l    d0,(a1)
  336.     jsr    _geta4
  337.     jsr    _exceptHandler
  338.     rts
  339.  
  340. #endasm
  341.  
  342.  
  343. exceptHandler()    
  344. {
  345.     int (*efunc)();
  346.     int sigpaws(), sigquit();
  347.  
  348.     exceptFlag = 1;
  349.     exceptSigs &= ~exceptSig;    /* simulate signal behaviour */
  350.  
  351.     efunc = exceptSig == SIGBREAKF_CTRL_D ? intrCode : quitCode;
  352.  
  353.     if (efunc == sigquit)
  354.         quitsig++;
  355.     else
  356.         sigpaws();
  357.  
  358. LOGGER(("exceptHandler returns %lx\n", exceptSigs));
  359.     exceptFlag = 0;
  360.     return exceptSigs;
  361. }
  362.  
  363. /*******************************************************************/
  364.  
  365. signal(sig, func)
  366. int sig, (*func)();
  367. {
  368.     int exceptKey;
  369.  
  370. LOGGER(("signal() call; sig %d; flag %d\n", sig, exceptFlag));
  371.  
  372.     if (sig == SIGINT) {
  373.         exceptKey = SIGBREAKF_CTRL_D;
  374.         intrCode = func;
  375.     }
  376.     else {
  377.         exceptKey = SIGBREAKF_CTRL_C;
  378.         quitCode = func;
  379.     }
  380.  
  381.     exceptSigs |= exceptKey;
  382.  
  383.     if (!exceptFlag)
  384.         SetExcept(exceptKey, exceptKey);
  385.  
  386. LOGGER(("signal() returns\n"));
  387. }
  388.  
  389. /*******************************************************************/
  390. /* AMIGA specific LOGO keyword commands go here: */
  391.  
  392.  
  393. struct object *chdir(cmd)
  394. register struct object *cmd;
  395. {
  396.     register struct object *str;
  397.  
  398.     str = stringform(cmd);
  399.     if (!cd(str->obstr)) {
  400.         printf("Can't chdir to %s\n", str->obstr);
  401.         errhand();
  402.     }
  403.     return ((struct object *)(-1));
  404. }
  405.  
  406. static cd(name)
  407. char *name;
  408. {
  409.     struct FileInfoBlock *AllocMem();
  410.     struct FileLock *Lock(), *CurrentDir();
  411.     struct FileInfoBlock *fib;
  412.     struct FileLock *oldlock, *filelock;
  413.     int ok;
  414.  
  415.     ok = 0;
  416.     if (filelock = Lock(name, ACCESS_READ)) {
  417.         if (fib = AllocMem(sizeof(*fib), MEMF_PUBLIC)) {
  418.             if (Examine(filelock, fib)) {
  419.                 if (0 <= fib->fib_DirEntryType) {
  420.                     if (oldlock = CurrentDir(filelock)) {
  421.                         UnLock(oldlock);
  422.                         ok++;
  423.                     }
  424.                 }
  425.             }
  426.             FreeMem(fib, sizeof(*fib));
  427.         }
  428.     }
  429.     if (!ok)
  430.         UnLock(filelock);
  431.     return ok;
  432. }
  433.  
  434.